Scikit-learn Pipeline: A gépi tanulási munkafolyamat automatizálásának végső útmutatója

A gépi tanulás világában egy modell felépítése gyakran a csillogó utolsó lépésként van bemutatva. A tapasztalt adattudósok és ML mérnökök azonban tudják, hogy egy robusztus modellhez vezető út egy sor kulcsfontosságú, gyakran ismétlődő és hibalehetőségekkel teli lépéssel van kikövezve: adattisztítás, funkcióskálázás, kategorikus változók kódolása és még sok más. Ezen lépések külön-külön történő kezelése a képzési, validációs és tesztkészletekhez gyorsan logisztikai rémálommá válhat, ami finom hibákhoz és ami a legveszélyesebb, adatszivárgáshoz vezethet.

Itt jön a Scikit-learn Pipeline a segítségünkre. Ez nem csak egy kényelmi szempont; ez egy alapvető eszköz a professzionális, reprodukálható és gyártásra kész gépi tanulási rendszerek felépítéséhez. Ez az átfogó útmutató végigvezeti Önt mindenen, amit tudnia kell a Scikit-learn Pipeline-ok elsajátításához, az alapfogalmaktól a fejlett technikákig.

A probléma: A manuális gépi tanulási munkafolyamat

Vegyünk egy tipikus felügyelt tanulási feladatot. Mielőtt akár a model.fit() függvényt is meghívhatná, elő kell készítenie az adatait. Egy standard munkafolyamat így nézhet ki:

1. Adatok felosztása: Ossza fel az adatkészletét képzési és tesztkészletekre. Ez az első és legkritikusabb lépés annak biztosítására, hogy értékelni tudja a modell teljesítményét a nem látott adatokon.
2. Hiányzó értékek kezelése: Azonosítsa és pótolja a hiányzó adatokat a képzési készletben (pl. a középérték, a medián vagy egy konstans használatával).
3. Kategorikus jellemzők kódolása: Konvertálja a nem numerikus oszlopokat, mint például a „Country” vagy a „Product Category” numerikus formátumba olyan technikák alkalmazásával, mint a One-Hot Encoding vagy az Ordinal Encoding.
4. Numerikus jellemzők skálázása: Hozzon minden numerikus jellemzőt hasonló skálára olyan módszerekkel, mint a Standardization (StandardScaler) vagy a Normalization (MinMaxScaler). Ez kulcsfontosságú számos algoritmushoz, mint például az SVM-ek, a logisztikus regresszió és a neurális hálózatok.
5. A modell betanítása: Végül tanítsa be a kiválasztott gépi tanulási modellt az előfeldolgozott képzési adatokon.

Most, amikor előrejelzéseket szeretne készíteni a tesztkészleten (vagy új, nem látott adatokon), pontosan ugyanazokat az előfeldolgozási lépéseket kell megismételnie. Alkalmaznia kell ugyanazt a pótlási stratégiát (a képzési készletből számított értékkel), ugyanazt a kódolási sémát és ugyanazokat a skálázási paramétereket. Az összes illesztett transzformátor manuális nyomon követése fáradságos és a hibák fő forrása.

A legnagyobb kockázat itt az adatszivárgás. Ez akkor fordul elő, amikor a tesztkészletből származó információk véletlenül beszivárognak a képzési folyamatba. Például, ha a hiányzó értékek pótlásához szükséges középértéket vagy a skálázási paramétereket a teljes adatkészletből számítja ki a felosztás előtt, akkor a modell implicit módon a tesztadatokból tanul. Ez túlságosan optimista teljesítménybecsléshez és egy olyan modellhez vezet, amely csúnyán elbukik a valós világban.

A Scikit-learn Pipeline bemutatása: Az automatizált megoldás

A Scikit-learn Pipeline egy olyan objektum, amely több adattranszformációs lépést és egy végső becslőt (például egy osztályozót vagy regresszort) fűz össze egyetlen, egységes objektumba. Úgy gondolhat rá, mint egy szerelőszalagra az adatai számára.

Amikor meghívja a .fit() függvényt egy Pipeline-on, az egymás után alkalmazza a fit_transform() függvényt minden közbenső lépésre a képzési adatokon, az egyik lépés kimenetét a következő lépés bemeneteként átadva. Végül meghívja a .fit() függvényt az utolsó lépésre, a becslőre. Amikor meghívja a .predict() vagy a .transform() függvényt a Pipeline-on, az csak az egyes közbenső lépések .transform() metódusát alkalmazza az új adatokra, mielőtt előrejelzést készítene a végső becslővel.

A Pipeline-ok használatának fő előnyei

• Adatszivárgás megakadályozása: Ez a legkritikusabb előny. Azáltal, hogy az összes előfeldolgozást beágyazza a pipeline-ba, biztosítja, hogy a transzformációkat kizárólag a képzési adatokból tanulják meg a keresztvalidáció során, és helyesen alkalmazzák a validációs/teszt adatokra.
• Egyszerűség és szervezettség: A teljes munkafolyamat, a nyers adatoktól a betanított modellig, egyetlen objektumba van sűrítve. Ez tisztábbá, olvashatóbbá és könnyebben kezelhetővé teszi a kódot.
• Reprodukálhatóság: Egy Pipeline objektum magában foglalja a teljes modellezési folyamatot. Könnyedén elmentheti ezt az egyetlen objektumot (pl. a `joblib` vagy a `pickle` használatával), és később betöltheti, hogy előrejelzéseket készítsen, biztosítva, hogy minden alkalommal pontosan ugyanazokat a lépéseket kövessék.
• Hatékonyság a rács keresésben: Hiperparaméter hangolást végezhet a teljes pipeline-on egyszerre, megtalálva a legjobb paramétereket mind az előfeldolgozási lépésekhez, mind a végső modellhez egyidejűleg. Ezt a hatékony funkciót később fogjuk feltárni.

Az első egyszerű Pipeline felépítése

Kezdjük egy alapvető példával. Képzeljük el, hogy van egy numerikus adatkészletünk, és skálázni szeretnénk az adatokat, mielőtt betanítunk egy logisztikus regressziós modellt. Íme, hogyan építene fel egy pipeline-t ehhez.

Először is, állítsuk be a környezetünket, és hozzunk létre néhány mintaadatot.

            
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score

# Generate some sample data
X, y = np.random.rand(100, 5) * 10, (np.random.rand(100) > 0.5).astype(int)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

            

              
                Copy
              
            
          

Most pedig definiáljuk a pipeline-unkat. Egy pipeline úgy jön létre, hogy megadunk egy listát a lépésekről. Minden lépés egy tuple, amely tartalmaz egy nevet (egy tetszőleges karakterláncot) és magát a transzformátor vagy becslő objektumot.

            
# Create the pipeline steps
steps = [
    ('scaler', StandardScaler()),
    ('classifier', LogisticRegression())
]

# Create the Pipeline object
pipe = Pipeline(steps)

# Now, you can treat the 'pipe' object as if it were a regular model.
# Let's train it on our training data.
pipe.fit(X_train, y_train)

# Make predictions on the test data
y_pred = pipe.predict(X_test)

# Evaluate the model
accuracy = accuracy_score(y_test, y_pred)
print(f"Pipeline Accuracy: {accuracy:.4f}")

            

              
                Copy
              
            
          

Ennyi! Néhány sorban kombináltuk a skálázást és az osztályozást. A Scikit-learn kezeli az összes közbenső logikát. Amikor meghívjuk a pipe.fit(X_train, y_train) függvényt, az először meghívja a StandardScaler().fit_transform(X_train) függvényt, majd az eredményt átadja a LogisticRegression().fit() függvénynek. Amikor meghívjuk a pipe.predict(X_test) függvényt, az alkalmazza a már illesztett skálázót a StandardScaler().transform(X_test) segítségével, mielőtt előrejelzéseket készítene a logisztikus regressziós modellel.

Heterogén adatok kezelése: A `ColumnTransformer`

Itt ragyog a ColumnTransformer. Lehetővé teszi, hogy különböző transzformátorokat alkalmazzon az adatok különböző oszlopainak részhalmazaira, majd intelligensen összefűzze az eredményeket. Ez a tökéletes eszköz arra, hogy egy nagyobb pipeline-on belül előfeldolgozási lépésként használja.

Példa: Numerikus és kategorikus jellemzők kombinálása

Hozzuk létre egy reálisabb adatkészletet numerikus és kategorikus jellemzőkkel a pandas használatával.

            
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.impute import SimpleImputer

# Create a sample DataFrame
data = {
    'age': [25, 30, 45, 35, 50, np.nan, 22],
    'salary': [50000, 60000, 120000, 80000, 150000, 75000, 45000],
    'country': ['USA', 'Canada', 'USA', 'UK', 'Canada', 'USA', 'UK'],
    'purchased': [0, 1, 1, 0, 1, 1, 0]
}
df = pd.DataFrame(data)

X = df.drop('purchased', axis=1)
y = df['purchased']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Identify numerical and categorical columns
numerical_features = ['age', 'salary']
categorical_features = ['country']

            

              
                Copy
              
            
          

Az előfeldolgozási stratégiánk a következő lesz:

1. A numerikus oszlopok (age, salary) esetében: A hiányzó értékeket a mediánnal pótoljuk, majd skálázzuk őket.
2. A kategorikus oszlopok (country) esetében: A hiányzó értékeket a leggyakoribb kategóriával pótoljuk, majd one-hot kódoljuk őket.

Ezeket a lépéseket két különálló mini-pipeline segítségével definiálhatjuk.

            
# Create a pipeline for numerical features
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# Create a pipeline for categorical features
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])

            

              
                Copy
              
            
          

Most a `ColumnTransformer` segítségével alkalmazzuk ezeket a pipeline-okat a megfelelő oszlopokra.

            
# Create the preprocessor with ColumnTransformer
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numerical_features),
        ('cat', categorical_transformer, categorical_features)
    ])

            

              
                Copy
              
            
          

Végül ezt a `preprocessor`-t az első lépésként helyezhetjük el a fő pipeline-unkban, amelyet a végső becslőnk követ.

            
from sklearn.ensemble import RandomForestClassifier

# Create the full pipeline
full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(random_state=42))
])

# Train and evaluate the full pipeline
full_pipeline.fit(X_train, y_train)

print("Model score on test data:", full_pipeline.score(X_test, y_test))

# You can now make predictions on new raw data
new_data = pd.DataFrame({
    'age': [40, 28],
    'salary': [90000, 55000],
    'country': ['USA', 'Germany'] # 'Germany' is an unknown category
})

predictions = full_pipeline.predict(new_data)
print("Predictions for new data:", predictions)

            

              
                Copy
              
            
          

Figyelje meg, milyen elegánsan kezeli ez a komplex munkafolyamatot. A `handle_unknown='ignore'` paraméter a `OneHotEncoder`-ben különösen hasznos a termelési rendszerekben, mivel megakadályozza a hibákat, amikor új, nem látott kategóriák jelennek meg az adatokban.

Speciális Pipeline technikák

Egyéni transzformátorok létrehozása

Néha a beépített Scikit-learn transzformátorok nem elegendőek. Előfordulhat, hogy egy domain-specifikus transzformációt kell végrehajtania, például egy jellemző logaritmusának kivonását vagy két jellemző kombinálását egy újba. Könnyedén létrehozhatja saját egyéni transzformátorait, amelyek zökkenőmentesen integrálódnak egy pipeline-ba.

Ehhez létre kell hoznia egy osztályt, amely a `BaseEstimator` és a `TransformerMixin` osztályokból öröklődik. Csak a `fit()` és a `transform()` metódusokat kell implementálnia (és egy `__init__()`-t, ha szükséges).

Hozzuk létre egy transzformátort, amely hozzáad egy új jellemzőt: a `salary` és az `age` arányát.

            
from sklearn.base import BaseEstimator, TransformerMixin

# Define column indices (can also pass names)
age_ix, salary_ix = 0, 1

class FeatureRatioAdder(BaseEstimator, TransformerMixin):
    def __init__(self):
        pass # No parameters to set
    def fit(self, X, y=None):
        return self # Nothing to learn during fit, so just return self
    def transform(self, X):
        salary_age_ratio = X[:, salary_ix] / X[:, age_ix]
        return np.c_[X, salary_age_ratio] # Concatenate original X with new feature

            

              
                Copy
              
            
          

Ezután ezt az egyéni transzformátort beilleszthetné a numerikus feldolgozó pipeline-jába:

            
numeric_transformer_with_custom = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('ratio_adder', FeatureRatioAdder()), # Our custom transformer
    ('scaler', StandardScaler())
])

            

              
                Copy
              
            
          

Ez a testreszabási szint lehetővé teszi, hogy a teljes jellemzőtervezési logikát beágyazza a pipeline-ba, így a munkafolyamat rendkívül hordozhatóvá és reprodukálhatóvá válik.

Hiperparaméter-hangolás Pipeline-okkal a `GridSearchCV` segítségével

Ez vitathatatlanul a Pipeline-ok egyik legerősebb alkalmazása. Egyszerre keresheti meg a legjobb hiperparamétereket a teljes munkafolyamathoz, beleértve az előfeldolgozási lépéseket és a végső modellt is.

Annak meghatározásához, hogy mely paramétereket kell hangolni, egy speciális szintaxist használ: `step_name__parameter_name`.

Bővítsük ki az előző példánkat, és hangoljuk be a hiperparamétereket mind a preprocessorunkban lévő imputerhez, mind a `RandomForestClassifier`-hez.

            
from sklearn.model_selection import GridSearchCV

# We use the 'full_pipeline' from the ColumnTransformer example

# Define the parameter grid
param_grid = {
    'preprocessor__num__imputer__strategy': ['mean', 'median'],
    'classifier__n_estimators': [50, 100, 200],
    'classifier__max_depth': [None, 10, 20],
    'classifier__min_samples_leaf': [1, 2, 4]
}

# Create the GridSearchCV object
grid_search = GridSearchCV(full_pipeline, param_grid, cv=5, verbose=1, n_jobs=-1)

# Fit it to the data
grid_search.fit(X_train, y_train)

# Print the best parameters and score
print("Best parameters found: ", grid_search.best_params_)
print("Best cross-validation score: ", grid_search.best_score_)

# The best estimator is already refitted on the whole training data
best_model = grid_search.best_estimator_
print("Test set score with best model: ", best_model.score(X_test, y_test))

            

              
                Copy
              
            
          

Nézze meg alaposan a `param_grid` kulcsait:

• 'preprocessor__num__imputer__strategy': Ez a `SimpleImputer` `strategy` paraméterét célozza meg, amelynek a neve `imputer` a `num` nevű numerikus pipeline-ban, amely maga is a `preprocessor` nevű `ColumnTransformer`-ben van.
• 'classifier__n_estimators': Ez a végső becslő `n_estimators` paraméterét célozza meg, amelynek a neve `classifier`.

Ezzel a `GridSearchCV` helyesen kipróbál minden kombinációt, és megtalálja a teljes munkafolyamat optimális paraméterkészletét, teljesen megakadályozva az adatszivárgást a hangolási folyamat során, mivel minden előfeldolgozás minden keresztvalidációs hajtásban megtörténik.

A Pipeline vizualizálása és ellenőrzése

            
from sklearn import set_config

# Set display to 'diagram' to get the visual representation
set_config(display='diagram')

# Now, simply displaying the pipeline object in a Jupyter Notebook or similar environment will render it
full_pipeline

            

              
                Copy
              
            
          

Ez egy diagramot generál, amely megmutatja az adatok áramlását az egyes transzformátorokon és becslőkön keresztül, a nevükkel együtt. Ez hihetetlenül hasznos a hibakereséshez, a munka megosztásához és a modell szerkezetének megértéséhez.

A felszerelt pipeline egyes lépéseit a nevük segítségével is elérheti:

            
# Access the final classifier of the fitted pipeline
final_classifier = full_pipeline.named_steps['classifier']
print("Feature importances:", final_classifier.feature_importances_)

# Access the OneHotEncoder to see the learned categories
onehot_encoder = full_pipeline.named_steps['preprocessor'].named_transformers_['cat'].named_steps['onehot']
print("Categorical features learned:", onehot_encoder.categories_)

            

              
                Copy
              
            
          

Gyakori buktatók és bevált gyakorlatok

1. Helytelen adatokra illesztés: Mindig, mindig csak a képzési adatokra illessze a pipeline-t. Soha ne illessze a teljes adatkészletre vagy a tesztkészletre. Ez a kardinális szabály az adatszivárgás megelőzésére.
2. Adatformátumok: Ügyeljen az egyes lépések által várt adatformátumra. Egyes transzformátorok (például az egyéni példánkban szereplők) NumPy tömbökkel működhetnek, míg mások kényelmesebbek a Pandas DataFrame-ekkel. A Scikit-learn általában jól kezeli ezt, de érdemes odafigyelni rá, különösen az egyéni transzformátorok esetében.
3. Pipeline-ok mentése és betöltése: A modell telepítéséhez el kell mentenie a felszerelt pipeline-t. Ennek standard módja a Python ökoszisztémában a `joblib` vagy a `pickle`. A `joblib` gyakran hatékonyabb a nagyméretű NumPy tömböket hordozó objektumok esetében.

               
   import joblib
   
   # Save the pipeline
   joblib.dump(full_pipeline, 'my_model_pipeline.joblib')
   
   # Load the pipeline later
   loaded_pipeline = joblib.load('my_model_pipeline.joblib')
   
   # Make predictions with the loaded model
   loaded_pipeline.predict(new_data)
   
               
   
                 
                   Copy
                 
               
             

4. Használjon leíró neveket: Adjon a pipeline lépéseinek és a `ColumnTransformer` összetevőinek világos, leíró neveket (pl. 'numeric_imputer', 'categorical_encoder', 'svm_classifier'). Ez olvashatóbbá teszi a kódot, és egyszerűsíti a hiperparaméter-hangolást és a hibakeresést.

Következtetés: Miért nem alku tárgya a Pipeline-ok a professzionális ML számára

A pipeline-ok elfogadásával a következőket kapja:

• Robusztusság: Kiküszöböli a gépi tanulási projektek leggyakoribb hibaforrását – az adatszivárgást.
• Hatékonyság: Egyszerűsíti a teljes munkafolyamatot, a funkciótervezéstől a hiperparaméter-hangolásig, egyetlen, összefüggő egységbe.
• Reprodukálhatóság: Létrehoz egyetlen, szerializálható objektumot, amely tartalmazza a teljes modelllogikáját, így könnyen telepíthető és megosztható.

Ha komolyan gondolja a gépi tanulási modellek építését, amelyek megbízhatóan működnek a valós világban, akkor a Scikit-learn Pipeline-ok elsajátítása nem opcionális – hanem elengedhetetlen. Kezdje el beépíteni őket a projektjeibe még ma, és jobb, megbízhatóbb modelleket fog építeni gyorsabban, mint valaha.